package base.jdk8_demo.lambda.demo05;


import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * 鉴于目前介绍的案例来看，对于每个业务都要我们提供一个函数式接口，非常不方便，为此：
 * 从这以后介绍 jdk8 为我们提供的四大函数类型接口
 *
 * Consumer<T>：消费型接口
 *              void accept(T t)
 *
 *Supplier<T>：供给型接口
 *             T get()
 *
 *Function<T, R>：函数型接口
 *               R apply(T t)
 *
 *Predicate<T>：断言型接口
 *              boolean test(T t)
 */
public class TestConsumer {

    static class Services {
        // 测试 Consumer 的业务接口
        public static void consumerService(double money, Consumer<Double> consumer){
            consumer.accept(money);
        }

        // 测试 Supplier 的业务接口
        // 产生指定个数的整数，并放入集合中返回。每个生成的整数暂不明确怎么个生成规则。
        public static List<Integer> supplierService(int num, Supplier<Integer> supplier){
            List<Integer> numList = new ArrayList<>();
            for (int i = 0; i < num; i++) {
                Integer integer = supplier.get();
                numList.add(integer);
            }
            return numList;
        }

        // 测试 Function 的业务接口
        public static String strHandler(String str, Function<String, String> fun){
            String newStr = fun.apply(str);
            return newStr;
        }

        // 测试 Predicate 的业务接口
        public static List<String> filterStr(List<String> list, Predicate<String> predicate){
            List<String> newList = new ArrayList<>();
            for (String s : list) {
                boolean b = predicate.test(s);
                if(b){
                    newList.add(s);
                }
            }
            return newList;
        }
    }

    // 需求：打印输出某种消费金额
    @Test
    public void testConsumer(){
        Services.consumerService(10000, money -> System.out.println("投资学习耗费："+money+"元"));
    }

    // 需求：随机生成10个0-100以内的整数集合
    @Test
    public void testSupplier(){
        List<Integer> list = Services.supplierService(10, () -> (int) (Math.random() * 100));
        System.out.println(list);
    }

    // 需求：对字符串进行操作,并返回操作后的新字符串
    @Test
    public void testFunction(){
        String tar = "\t\t\t  Just Do It Now  ";
        String newStr = Services.strHandler(tar, (str) -> str.trim());
        System.out.println(newStr);

        newStr = Services.strHandler(newStr, (str) -> str.substring(5, 10));
        System.out.println(newStr);
    }

    // 需求：将集合中的字符串进行过滤
    @Test
    public void testPredicate(){
        List<String> list = Arrays.asList("www.baidu.com","www.google.cn","www","cn");
        List<String> newList = Services.filterStr(list, (str) -> str.length() > 3);
        System.out.println(newList);
    }
}
